/**
 * 管理员API处理
 */

import { Database } from '../db/database.js';

// 处理管理员相关的API请求
export async function handleAdminAPI(request, env) {
  try {
    const url = new URL(request.url);
    const path = url.pathname;
    const method = request.method;
    
    // 解析请求体
    let requestBody = null;
    if (method === 'POST' || method === 'PUT') {
      try {
        requestBody = await request.json();
      } catch (jsonError) {
        return new Response(JSON.stringify({
          error: '无效的JSON格式'
        }), {
          status: 400,
          headers: {
            'Content-Type': 'application/json'
          }
        });
      }
    }
    
    // API路由处理
    
    // 管理员登录
    if (path === '/api/admin/login' && method === 'POST') {
      return await adminLogin(requestBody, env);
    }
    
    // 管理员登出
    if (path === '/api/admin/logout' && method === 'POST') {
      return await adminLogout(request);
    }
    
    // 验证管理员会话
    if (path === '/api/admin/verify' && method === 'GET') {
      // 验证管理员权限
      const adminInfo = await verifyAdminSession(request, env);
      if (!adminInfo) {
        return new Response(JSON.stringify({
          error: '未授权，请先登录'
        }), {
          status: 401,
          headers: {
            'Content-Type': 'application/json'
          }
        });
      }
      
      return new Response(JSON.stringify({
        success: true,
        admin: {
          id: adminInfo.id,
          username: adminInfo.username
        }
      }), {
        status: 200,
        headers: {
          'Content-Type': 'application/json'
        }
      });
    }
    
    // 获取统计数据
    if (path === '/api/admin/stats' && method === 'GET') {
      // 验证管理员权限
      const adminInfo = await verifyAdminSession(request, env);
      if (!adminInfo) {
        return new Response(JSON.stringify({
          error: '未授权，请先登录'
        }), {
          status: 401,
          headers: {
            'Content-Type': 'application/json'
          }
        });
      }
      
      return await getStats(env);
    }
    
    // 未匹配的路由
    return new Response(JSON.stringify({
      error: '管理员API路由不存在',
      path: path
    }), {
      status: 404,
      headers: {
        'Content-Type': 'application/json'
      }
    });
    
  } catch (error) {
    console.error('管理员API处理错误:', error);
    return new Response(JSON.stringify({
      error: '服务器内部错误',
      message: error.message || '未知错误'
    }), {
      status: 500,
      headers: {
        'Content-Type': 'application/json'
      }
    });
  }
}

// 管理员登录
async function adminLogin(data, env) {
  try {
    // 验证请求数据
    if (!data || !data.username || !data.password) {
      return new Response(JSON.stringify({
        error: '用户名和密码不能为空'
      }), {
        status: 400,
        headers: {
          'Content-Type': 'application/json'
        }
      });
    }
    
    const { username, password } = data;
    const db = new Database(env);
    
    // 验证管理员凭据
    const admin = await db.verifyAdmin(username, password);
    
    if (!admin) {
      return new Response(JSON.stringify({
        error: '用户名或密码错误'
      }), {
        status: 401,
        headers: {
          'Content-Type': 'application/json'
        }
      });
    }
    
    // 生成会话token（简单实现）
    // 实际项目中应该使用更安全的方式生成token，如JWT
    const token = generateSessionToken(admin.id, admin.username);
    
    // 在实际项目中，应该将token存储在KV或其他持久化存储中
    // 这里只是演示
    
    // 设置cookie（在Cloudflare Workers中，使用Response的headers设置Set-Cookie）
    const response = new Response(JSON.stringify({
      success: true,
      message: '登录成功',
      token: token,
      admin: {
        id: admin.id,
        username: admin.username
      }
    }), {
      status: 200,
      headers: {
        'Content-Type': 'application/json'
      }
    });
    
    // 设置安全的cookie
    response.headers.append('Set-Cookie', `admin_token=${token}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=3600`);
    
    return response;
    
  } catch (error) {
    console.error('管理员登录失败:', error);
    return new Response(JSON.stringify({
      error: '登录失败',
      message: error.message || '未知错误'
    }), {
      status: 500,
      headers: {
        'Content-Type': 'application/json'
      }
    });
  }
}

// 管理员登出
async function adminLogout(request) {
  try {
    // 清除cookie
    const response = new Response(JSON.stringify({
      success: true,
      message: '登出成功'
    }), {
      status: 200,
      headers: {
        'Content-Type': 'application/json'
      }
    });
    
    // 设置过期的cookie
    response.headers.append('Set-Cookie', `admin_token=; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=0`);
    
    return response;
    
  } catch (error) {
    console.error('管理员登出失败:', error);
    return new Response(JSON.stringify({
      error: '登出失败',
      message: error.message || '未知错误'
    }), {
      status: 500,
      headers: {
        'Content-Type': 'application/json'
      }
    });
  }
}

// 验证管理员会话
async function verifyAdminSession(request, env) {
  try {
    // 从cookie中获取token
    const cookie = request.headers.get('Cookie') || '';
    const tokenMatch = cookie.match(/admin_token=([^;]+)/);
    
    if (!tokenMatch || !tokenMatch[1]) {
      return null;
    }
    
    const token = tokenMatch[1];
    
    // 验证token
    // 实际项目中应该从KV或其他存储中验证token的有效性
    // 这里只是简单的演示
    const decodedInfo = verifySessionToken(token);
    
    if (!decodedInfo) {
      return null;
    }
    
    // 验证管理员是否存在
    const db = new Database(env);
    // 这里应该有一个方法来获取管理员信息
    // 暂时返回解码后的信息
    return decodedInfo;
    
  } catch (error) {
    console.error('验证管理员会话失败:', error);
    return null;
  }
}

// 获取统计数据
async function getStats(env) {
  try {
    const db = new Database(env);
    
    // 获取总投稿数
    const totalSubmissions = await db.getSubmissions(1, 1, null);
    
    // 获取待审核投稿数
    const pendingSubmissions = await db.getSubmissions(1, 1, 0);
    
    // 获取已通过投稿数
    const approvedSubmissions = await db.getSubmissions(1, 1, 1);
    
    // 获取已拒绝投稿数
    const rejectedSubmissions = await db.getSubmissions(1, 1, 2);
    
    return new Response(JSON.stringify({
      success: true,
      stats: {
        total: totalSubmissions.total,
        pending: pendingSubmissions.total,
        approved: approvedSubmissions.total,
        rejected: rejectedSubmissions.total
      }
    }), {
      status: 200,
      headers: {
        'Content-Type': 'application/json'
      }
    });
    
  } catch (error) {
    console.error('获取统计数据失败:', error);
    return new Response(JSON.stringify({
      error: '获取统计数据失败',
      message: error.message || '未知错误'
    }), {
      status: 500,
      headers: {
        'Content-Type': 'application/json'
      }
    });
  }
}

// 生成会话token（简单实现）
function generateSessionToken(adminId, username) {
  // 实际项目中应该使用更安全的方式生成token
  const timestamp = Date.now();
  const data = `${adminId}|${username}|${timestamp}`;
  // 简单的base64编码，实际项目中应该使用加密算法
  return btoa(data);
}

// 验证会话token（简单实现）
function verifySessionToken(token) {
  try {
    // 实际项目中应该使用更安全的验证方式
    const decoded = atob(token);
    const [adminId, username, timestamp] = decoded.split('|');
    
    // 验证时间戳，token有效期1小时
    const now = Date.now();
    const tokenAge = now - parseInt(timestamp);
    const maxAge = 3600 * 1000; // 1小时
    
    if (tokenAge > maxAge) {
      return null;
    }
    
    return {
      id: parseInt(adminId),
      username
    };
    
  } catch (error) {
    console.error('验证token失败:', error);
    return null;
  }
}